/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.dp1.pucp.Produccion.DAO;

import com.dp1.pucp.Modelo.Clases.Almacen;
import com.dp1.pucp.Modelo.Clases.Demanda;
import com.dp1.pucp.Modelo.Clases.Empleado;
import com.dp1.pucp.Modelo.Clases.Empleadoxmaquinasimulacion;
import com.dp1.pucp.Modelo.Clases.Historico;
import com.dp1.pucp.Modelo.Clases.Kardex;
import com.dp1.pucp.Modelo.Clases.Lineapedidoproducto;
import com.dp1.pucp.Modelo.Clases.Materiaprima;
import com.dp1.pucp.Modelo.Clases.Pedidocompra;
import com.dp1.pucp.Modelo.Clases.Pedidoproduccion;
import com.dp1.pucp.Modelo.Clases.Pedidoproducto;
import com.dp1.pucp.Modelo.Clases.Presentacion;
import com.dp1.pucp.Modelo.Clases.Productofinal;
import com.dp1.pucp.Modelo.Clases.Productointermedio;
import com.dp1.pucp.Modelo.Clases.Productosimulacion;
import com.dp1.pucp.Modelo.Clases.Simulacion;
import com.dp1.pucp.Modelo.Clases.Tipomerma;
import com.dp1.pucp.Modelo.Clases.Tipoproducto;
import com.dp1.pucp.Modelo.Clases.Trabajo;
import com.dp1.pucp.Util.HibernateUtil;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 *
 * @author Rodrigo
 */
public class ProduccionDAO {
    
    public ArrayList<Simulacion> buscarSimulaciones(){
        return null;
    }
    
    public void guardarHistorico(Historico historico){
        
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(historico);
            tx.commit();
        } catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
        } 
    }
       public void guardarlinea(Lineapedidoproducto linea){
        
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(linea);
            tx.commit();
        } catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
        } 
    }
    public void guardarPedidoProduccion(Pedidoproduccion pedido) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(pedido);
            tx.commit();
        } catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
        }
    }
    public void guardarTrabajo(Trabajo trabajo) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(trabajo);
            tx.commit();
        } catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
        }
    }
    
     public void guardarProductoIntermedio(Productointermedio pint) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(pint);
            tx.commit();
        } catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
        }
    }
     
     public void guardarProductoFinal(Productofinal pinf) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(pinf);
            tx.commit();
        } catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
        }
    }
     
       public void guardarAjuste(Kardex kardex){
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx =  session.beginTransaction();
        try {
            session.saveOrUpdate(kardex);
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();            
        }        
    }
    
         public void guardarMP( Materiaprima mp){
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx =  session.beginTransaction();
        try {
            session.saveOrUpdate(mp);
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();            
        }        
    }
    
    
    public ArrayList<Simulacion> listarSimulaciones()
    {
        ArrayList<Simulacion> listaResultados = new ArrayList<>();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Simulacion where estado=5 order by Idsimulacion DESC").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Simulacion s = (Simulacion) iter.next();
                Hibernate.initialize(s.getIdsimulacion());
                Hibernate.initialize(s.getCantdecorada());
                Hibernate.initialize(s.getCantnormal());
                Hibernate.initialize(s.getCantrellena());
                Hibernate.initialize(s.getEstado());
                Hibernate.initialize(s.getFechaHora());             
                Hibernate.initialize(s.getMerma());
                Hibernate.initialize(s.getParametrosalgoritmo());
                Hibernate.initialize(s.getProduccion());
                Hibernate.initialize(s.getTurno()); 
                Hibernate.initialize(s.getEmpleadoxmaquinasimulacions()); 
                listaResultados.add(s);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
    }
    
    
    
    public ArrayList<Simulacion> listarSimulacionesPorFecha(Date fechai, Date fechaf)
    {
        ArrayList<Simulacion> listaResultados = new ArrayList<>();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Simulacion where estado=5 and Fecha_hora between '" + fechai +"' and '" + fechaf + "' order by Idsimulacion DESC").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Simulacion s = (Simulacion) iter.next();
                Hibernate.initialize(s.getIdsimulacion());
                Hibernate.initialize(s.getCantdecorada());
                Hibernate.initialize(s.getCantnormal());
                Hibernate.initialize(s.getCantrellena());
                Hibernate.initialize(s.getEstado());
                Hibernate.initialize(s.getFechaHora());             
                Hibernate.initialize(s.getMerma());
                Hibernate.initialize(s.getParametrosalgoritmo());
                Hibernate.initialize(s.getProduccion());
                Hibernate.initialize(s.getTurno());     
                Hibernate.initialize(s.getEmpleadoxmaquinasimulacions()); 
                listaResultados.add(s);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
    }
    
    public void setEstadoPedidoProduccion(int estado, int id){
        
    }
    
    public Pedidoproduccion getPedidoProduccion(int idPedido){
        Pedidoproduccion pedido = new Pedidoproduccion();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
             List lista = session.createQuery("from Pedidoproduccion where Idpedidoproduccion="+ idPedido +"").list();        
             Iterator iter = lista.iterator();
             if (iter.hasNext()) {   
                pedido = (Pedidoproduccion) iter.next();
                Hibernate.initialize(pedido.getIdpedidoproduccion());          
                Hibernate.initialize(pedido.getCantidad());             
                Hibernate.initialize(pedido.getCantidadCubierta());
                Hibernate.initialize(pedido.getEstado());
                Hibernate.initialize(pedido.getFecha());
                Hibernate.initialize(pedido.getSimulacion());
                Hibernate.initialize(pedido.getTipoproducto());
                Hibernate.initialize(pedido.getTurno());   
                Hibernate.initialize(pedido.getTrabajos());  
            }        
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return pedido;
        }         
        
    }
    
    public void guardarPedidoproduccion(Pedidoproduccion pedido){
        
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(pedido);
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();            
        }       
    }
    
    public void setSimulacionPedidoProduccion(Pedidoproduccion pedido, Simulacion simulacion){
        
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        pedido.setSimulacion(simulacion);
        int estadonuevo=2;//poner valor de estado en proceso de atencion
        pedido.setEstado(estadonuevo);
        try {
            session.saveOrUpdate(pedido);
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();            
        }        
        
    }
    
    public ArrayList<Empleadoxmaquinasimulacion> listarEmpleadoMaquinaSimulacion(Simulacion simulacion){
        
        ArrayList<Empleadoxmaquinasimulacion> listaResultados = new ArrayList<>();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        
        try{
            List lista = session.createQuery("from Empleadoxmaquinasimulacion where idsimulacion = '" + simulacion.getIdsimulacion() + "' order by idempleadoxmaquinasimulacion").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Empleadoxmaquinasimulacion e = (Empleadoxmaquinasimulacion) iter.next();
                Hibernate.initialize(e.getEmpleado());
                Hibernate.initialize(e.getIdempleadoxmaquinasimulacion());
                Hibernate.initialize(e.getMaquina());
                Hibernate.initialize(e.getSimulacion());
                Hibernate.initialize(e.getTipoproducto());
//                Hibernate.initialize(e.ProdReal());
//                Hibernate.initialize(e.MermaReal());
                listaResultados.add(e);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }       
        
    }
    
    public Tipomerma getTipomermaporId(int id){
        
        Tipomerma tipo = new Tipomerma();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
             List lista = session.createQuery("from Tipomerma where Idtipomerma="+ id +"").list();        
             Iterator iter = lista.iterator();
             if (iter.hasNext()) {   
                tipo = (Tipomerma) iter.next();
                Hibernate.initialize(tipo.getIdtipomerma());          
                Hibernate.initialize(tipo.getNombre());             
                Hibernate.initialize(tipo.getDescripcion());
                Hibernate.initialize(tipo.getProductoxmaquinas());
                Hibernate.initialize(tipo.getRecetaPfMps());
                Hibernate.initialize(tipo.getTrabajos());
            }        
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return tipo;
        }
    }
    
    public ArrayList<Pedidoproduccion> listarPedidoProduccionPorEstado(int estado)
    {
        ArrayList<Pedidoproduccion> listaResultados = new ArrayList<>();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Pedidoproduccion where estado = '" + estado + "' order by Idpedidoproduccion").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Pedidoproduccion p = (Pedidoproduccion) iter.next();
                Hibernate.initialize(p.getCantidad());
                Hibernate.initialize(p.getCantidadCubierta());
                Hibernate.initialize(p.getEstado());
                Hibernate.initialize(p.getFecha());
                Hibernate.initialize(p.getIdpedidoproduccion());
                Hibernate.initialize(p.getTipoproducto());
                Hibernate.initialize(p.getTurno());   
               // Hibernate.initialize(p.getTrabajos());
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
    }
    
    
    public ArrayList<Pedidoproduccion> listarPedidosProduccionPorFecha(Date fechai, Date fechaf)
    {
        ArrayList<Pedidoproduccion> listaResultados = new ArrayList<>();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Pedidoproduccion where Fecha between '" + fechai +"' and '" + fechaf + "' and Estado=1 order by Idpedidoproduccion DESC").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Pedidoproduccion p = (Pedidoproduccion) iter.next();
                Hibernate.initialize(p.getCantidad());
                Hibernate.initialize(p.getCantidadCubierta());
                Hibernate.initialize(p.getEstado());
                Hibernate.initialize(p.getFecha());
                Hibernate.initialize(p.getIdpedidoproduccion());
                Hibernate.initialize(p.getTipoproducto());
                Hibernate.initialize(p.getTurno()); 
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
    }
    
    
    
    
    public ArrayList<Pedidoproduccion> listarPedidoProduccionPorSimulacion(Simulacion simulacion)
    {
        ArrayList<Pedidoproduccion> listaResultados = new ArrayList<>();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Pedidoproduccion where Idsimulacion = '" + simulacion.getIdsimulacion() + "' order by Idpedidoproduccion").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Pedidoproduccion p = (Pedidoproduccion) iter.next();
                Hibernate.initialize(p.getCantidad());
                Hibernate.initialize(p.getCantidadCubierta());
                Hibernate.initialize(p.getEstado());
                Hibernate.initialize(p.getFecha());
                Hibernate.initialize(p.getIdpedidoproduccion());
                Hibernate.initialize(p.getTipoproducto());
                Hibernate.initialize(p.getTurno()); 
                
                //Hibernate.initialize(p.getTrabajos());
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
    }
    
     public ArrayList<Productosimulacion> listarProductoPorSimulacion(Simulacion simulacion)
    {
        ArrayList<Productosimulacion> listaResultados = new ArrayList<>();       
       Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Productosimulacion where Idsimulacion = '" + simulacion.getIdsimulacion() + "' ").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Productosimulacion p = (Productosimulacion) iter.next();
                Hibernate.initialize(p.getIdproductosimulacion());
                Hibernate.initialize(p.getTipoproducto());
                Hibernate.initialize(p.getSimulacion());
                Hibernate.initialize(p.getCantProducida());
                Hibernate.initialize(p.getCantMerma());
                Hibernate.initialize(p.getTipoproducto());
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }    
        
        
    }
    
     public Productointermedio getInventario(int id){//falta
       Productointermedio producto = new Productointermedio();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Productointermedio where idtipoproducto2="+id+"").list();     
            Iterator iter = lista.iterator();
          if (iter.hasNext()) {
                Productointermedio prodint = (Productointermedio)iter.next();
                Hibernate.initialize(prodint.getIdproductointermedio());          
                Hibernate.initialize(prodint.getTipoproductoByIdtipoproducto1());    
                Hibernate.initialize(prodint.getTipoproductoByIdtipoproducto2());                              
                Hibernate.initialize(prodint.getAlmacen());
                Hibernate.initialize(prodint.getCodigo());
                Hibernate.initialize(prodint.getDescripcion());
                Hibernate.initialize(prodint.getEstado());
                Hibernate.initialize(prodint.getVolumen());
                Hibernate.initialize(prodint.getFechaCaducidad());
                Hibernate.initialize(prodint.getLote());
                
                
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();           
        }              
        return producto;
    
    
    }
     
     public Productosimulacion getProductoSimulacion(int tipo, int idsimu){
        Productosimulacion prod = new Productosimulacion();
         Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
    try{
        List lista = session.createQuery("from Productosimulacion where idsimulacion =" + idsimu +" and idtipoproducto=" + tipo + "").list();        
            Iterator iter = lista.iterator();
            if(iter.hasNext()){
                prod = (Productosimulacion)iter.next();
                Hibernate.initialize(prod.getIdproductosimulacion());          
                Hibernate.initialize(prod.getSimulacion());   
                Hibernate.initialize(prod.getTipoproducto());          
                Hibernate.initialize(prod.getCantProducida());         
                Hibernate.initialize(prod.getCantMerma());                        
                Hibernate.initialize(prod.getProdReal());                
                Hibernate.initialize(prod.getMermaReal());
            
            }
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return prod;
        }         

}
    
//     public ArrayList<Trabajo> listarTrabajoporsimuymaquina(int idsimu){
//      ArrayList<Trabajo> listaResultados = new ArrayList<>();       
//       Session session = HibernateUtil.getSessionFactory().openSession();
//        Transaction tx = session.beginTransaction();
//        try{
//            List lista = session.createQuery("from Trabajo where Idsimulacion = '" + idsimu + "' ").list();        
//            Iterator iter = lista.iterator();
//            while (iter.hasNext()) {    
//                Productosimulacion p = (Productosimulacion) iter.next();
//                Hibernate.initialize(p.getIdproductosimulacion());
//                Hibernate.initialize(p.getTipoproducto());
//                Hibernate.initialize(p.getSimulacion());
//                Hibernate.initialize(p.getCantProducida());
//                Hibernate.initialize(p.getCantMerma());
//                Hibernate.initialize(p.getTipoproducto());
//                listaResultados.add(p);
//            }        
//            tx.commit();
//        } catch(HibernateException e) {
//            throw new HibernateException(e);    
//        } finally {
//            session.close();
//            return listaResultados;
//        }    
//       
//         
//     
//     
//     }
    
    public Empleado getOperarioSeleccionado(int idemp){
       Empleado emp = new Empleado();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Empleado where idempleado = "+ idemp +"").list();        
            Iterator iter = lista.iterator();
            if (iter.hasNext()) {    
               emp = (Empleado) iter.next();
                Hibernate.initialize(emp.getCodigo());
                Hibernate.initialize(emp.getNombre());
                Hibernate.initialize(emp.getApPaterno());
                Hibernate.initialize(emp.getApMaterno());                           
                Hibernate.initialize(emp.getEstado());                             
                Hibernate.initialize(emp.getIdempleado());                
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return emp;
        }         
     
     }
    
    public void guardarPF (Productointermedio pi){
     Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx =  session.beginTransaction();
        try {
            session.saveOrUpdate(pi);
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();            
        }        
    }

    public void guardarDemanda(Demanda dem){
     Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx =  session.beginTransaction();
        try {
            session.saveOrUpdate(dem);
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();            
        }        
    }
    
    public Demanda getDemandasBySimulacion(Simulacion simulacion){
        Demanda p = new Demanda();       
       Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Demanda where Idsimulacion = " + simulacion.getIdsimulacion() + "").list();        
            Iterator iter = lista.iterator();
            if (iter.hasNext()) {    
                p = (Demanda) iter.next();
                    Hibernate.initialize(p.getIddemanda());
                Hibernate.initialize(p.getCantPedDec());
                Hibernate.initialize(p.getCantPedNormal());
                Hibernate.initialize(p.getCantPedRell());
                Hibernate.initialize(p.getCrealNormal());
                Hibernate.initialize(p.getCrealPed());
                Hibernate.initialize(p.getDemandaxpedidoproductos());
                Hibernate.initialize(p.getEstado());
                Hibernate.initialize(p.getFecha());
                Hibernate.initialize(p.getFechaCubierta());
                Hibernate.initialize(p.getSimulacion());
                Hibernate.initialize(p.getTurno());
                
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return p;
        }  
        
    }
    
    
   
    public ArrayList<Pedidoproducto> getPedProbyDem(Demanda dem){
        ArrayList<Pedidoproducto> listaResultados = new ArrayList();
    Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Demandaxpedidoproductos where iddemanda = " + dem.getIddemanda()+ "").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Pedidoproducto p = (Pedidoproducto) iter.next();
                Hibernate.initialize(p.getEstado());
                Hibernate.initialize(p.getFechaRegistro());
                Hibernate.initialize(p.getIdpedidoproducto());
                Hibernate.initialize(p.getLineapedidoproductos());
                Hibernate.initialize(p.getTotal());
                
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }    
    }
    
    public Pedidoproduccion getPedidoBySimulacion(Simulacion simu, int tipoprod){
         Pedidoproduccion pedido = new Pedidoproduccion();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
             List lista = session.createQuery("from Pedidoproduccion where idsimulacion="+ simu.getIdsimulacion() +"and idtipoproducto ="+tipoprod+"").list();        
             Iterator iter = lista.iterator();
             if (iter.hasNext()) {   
                pedido = (Pedidoproduccion) iter.next();
                Hibernate.initialize(pedido.getIdpedidoproduccion());          
                Hibernate.initialize(pedido.getCantidad());             
                Hibernate.initialize(pedido.getCantidadCubierta());
                Hibernate.initialize(pedido.getEstado());
                Hibernate.initialize(pedido.getFecha());
                Hibernate.initialize(pedido.getSimulacion());
                Hibernate.initialize(pedido.getTipoproducto());
                Hibernate.initialize(pedido.getTurno());   
                Hibernate.initialize(pedido.getTrabajos());  
            }        
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return pedido;
        }         
        
    }
    
    
    public ArrayList<Lineapedidoproducto> getlineasByPedido(int id){
    
         ArrayList<Lineapedidoproducto> listaResultados = new ArrayList();
    Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Lineapedidoproducto where idpedidoproducto = " + id+ " order by idtipoproducto").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Lineapedidoproducto p = (Lineapedidoproducto) iter.next();
                Hibernate.initialize(p.getCantidad());
                Hibernate.initialize(p.getCantidadCubierta());
                Hibernate.initialize(p.getIdlineapedidoproducto());
                Hibernate.initialize(p.getPUnitario());
                Hibernate.initialize(p.getPedidoproducto());
                Hibernate.initialize(p.getPresentacion());
                Hibernate.initialize(p.getPresentacion().getCantidad());
                Hibernate.initialize(p.getPresentacion().getDescripcion());
                Hibernate.initialize(p.getPresentacion().getEstado());
                Hibernate.initialize(p.getPresentacion().getIdpresentacion());
                Hibernate.initialize(p.getPresentacion().getNombre());
                Hibernate.initialize(p.getPresentacion().getVolumen());                
                Hibernate.initialize(p.getSubtotal());
                Hibernate.initialize(p.getTipoproducto());
                
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        } 
    
    }
    
     public void guardarProductoIntermedio(Lineapedidoproducto linea) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.saveOrUpdate(linea);
            tx.commit();
        } catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
        }
    }
     
     public ArrayList<Simulacion> getSimulacionesNoSeleccionadas(int idselec, int turno){
         ArrayList<Simulacion> listaResultados = new ArrayList();
         Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Simulacion where turno = " + turno+ " and idsimulacion <>" +idselec + "order by idtipoproducto").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Simulacion p = (Simulacion) iter.next();
                Hibernate.initialize(p.getIdsimulacion());
                Hibernate.initialize(p.getEstado());
                Hibernate.initialize(p.getTurno());
                
                listaResultados.add(p);
            }        
            tx.commit();
        }catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
             return listaResultados;
        }
  
     }
     
     public ArrayList<Empleadoxmaquinasimulacion> getEmplexMaq(int idsimu){
         ArrayList<Empleadoxmaquinasimulacion> listaResultados = new ArrayList();
         Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Empleadoxmaquinasimulacion where idsimulacion = " + idsimu+ "").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Empleadoxmaquinasimulacion p = (Empleadoxmaquinasimulacion) iter.next();
                Hibernate.initialize(p.getEmpleado());
                  Hibernate.initialize(p.getEmpleado().getIdempleado());
                    Hibernate.initialize(p.getEmpleado().getEstado());
                Hibernate.initialize(p.getIdempleadoxmaquinasimulacion());
                Hibernate.initialize(p.getMaquina());
                Hibernate.initialize(p.getMaquina().getIdmaquina());
                Hibernate.initialize(p.getMaquina().getEstado());
                Hibernate.initialize(p.getMermaReal());
                Hibernate.initialize(p.getProdReal());
                Hibernate.initialize(p.getSimulacion());
                Hibernate.initialize(p.getTipoproducto());
                listaResultados.add(p);
            }        
            tx.commit();
        }catch (HibernateException e) {
            throw new HibernateException(e);
        } finally {
            session.close();
             return listaResultados;
        }
     }
     
     public ArrayList<Simulacion> listarSimulaciones(int estado)
    {
        ArrayList<Simulacion> listaResultados = new ArrayList<>();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Simulacion where estado ="+ estado+"").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Simulacion s = (Simulacion) iter.next();
                Hibernate.initialize(s.getIdsimulacion());
                Hibernate.initialize(s.getCantdecorada());
                Hibernate.initialize(s.getCantnormal());
                Hibernate.initialize(s.getCantrellena());
                Hibernate.initialize(s.getEstado());
                Hibernate.initialize(s.getFechaHora());             
                Hibernate.initialize(s.getMerma());
                Hibernate.initialize(s.getParametrosalgoritmo());
                Hibernate.initialize(s.getProduccion());
                Hibernate.initialize(s.getTurno()); 
                Hibernate.initialize(s.getEmpleadoxmaquinasimulacions()); 
                listaResultados.add(s);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
    } 
     
     public ArrayList<Pedidoproduccion> listarPedidosproduccion(Simulacion simulacion)
    {
        ArrayList<Pedidoproduccion> listaResultados = new ArrayList<>();       
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Pedidoproduccion where Idsimulacion ="+ simulacion.getIdsimulacion()+"").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Pedidoproduccion p = (Pedidoproduccion) iter.next();
                Hibernate.initialize(p.getIdpedidoproduccion());
                Hibernate.initialize(p.getCantidad());
                Hibernate.initialize(p.getCantidadCubierta());
                Hibernate.initialize(p.getEstado());
                Hibernate.initialize(p.getFecha());
                Hibernate.initialize(p.getSimulacion());             
                Hibernate.initialize(p.getTipoproducto());
                Hibernate.initialize(p.getTurno());
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
    } 
    
     public Pedidoproduccion getpedBySimByProd(int idsim, int tiprod){
         Pedidoproduccion pedido = new Pedidoproduccion();
         Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
             List lista = session.createQuery("from Pedidoproduccion where idsimulacion="+ idsim +" and idtipoproducto="+ tiprod +"").list();        
             Iterator iter = lista.iterator();
             if (iter.hasNext()) {   
                pedido = (Pedidoproduccion) iter.next();
                Hibernate.initialize(pedido.getIdpedidoproduccion());          
                Hibernate.initialize(pedido.getCantidad());             
                Hibernate.initialize(pedido.getCantidadCubierta());
                Hibernate.initialize(pedido.getEstado());
                Hibernate.initialize(pedido.getFecha());
                Hibernate.initialize(pedido.getSimulacion());
                Hibernate.initialize(pedido.getTipoproducto());
                Hibernate.initialize(pedido.getTurno());   
                Hibernate.initialize(pedido.getTrabajos());  
            }        
            tx.commit();
        }catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return pedido;
        }         
        
        
     }
     
     
     public Productofinal getProductoFinal(int idtipoproducto,int idPresentacion)
    {
       
        Productofinal pfinal = new Productofinal();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Productofinal where idpresentacion="+idPresentacion+"and idtipoproducto="+idtipoproducto+"").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                pfinal= (Productofinal) iter.next();
                Hibernate.initialize(pfinal.getAlmacen());
                Hibernate.initialize(pfinal.getCantidad());
                Hibernate.initialize(pfinal.getCodigo());
                Hibernate.initialize(pfinal.getPresentacion());
                Hibernate.initialize(pfinal.getDescripcion());
                Hibernate.initialize(pfinal.getEstado());
                Hibernate.initialize(pfinal.getFechaCaducidad());
                Hibernate.initialize(pfinal.getIdproductofinal());
                Hibernate.initialize(pfinal.getLote());
            }
            tx.commit();
            
            } catch(HibernateException e) {
            throw new HibernateException(e);  
        }finally {
            session.close();
            return pfinal;
            }
        }   
     
     public ArrayList<Presentacion> getPresentaciones(){
         ArrayList<Presentacion> listaResultados = new ArrayList();
          Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Presentacion order by idpresentacion").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                Presentacion p = (Presentacion) iter.next();
                Hibernate.initialize(p.getIdpresentacion());
                listaResultados.add(p);
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return listaResultados;
        }         
     
     }
     
      public Presentacion getPresentacion(int idpresen){
         Presentacion presentacion = new Presentacion();
          Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Presentacion where idpresentacion="+idpresen+"").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                 presentacion = (Presentacion) iter.next();
                Hibernate.initialize(presentacion.getIdpresentacion());
               
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return presentacion;
        }         
     
     }
      
      public Almacen getAlmacen(int id){
         Almacen almacen = new Almacen();
          Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();
        try{
            List lista = session.createQuery("from Almacen where idalmacen="+id+"").list();        
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {    
                 almacen = (Almacen) iter.next();
                Hibernate.initialize(almacen.getIdalmacen());
                Hibernate.initialize(almacen.getTipo());
                Hibernate.initialize(almacen.getEstado());
                Hibernate.initialize(almacen.getIdalmacen());
                Hibernate.initialize(almacen.getEspacioTotal());
                Hibernate.initialize(almacen.getEspacioUtilizado());
                
                Hibernate.initialize(almacen.getDescripcion());
                Hibernate.initialize(almacen.getEspacioLibre());
               
                Hibernate.initialize(almacen.getEspacioLibre());
            }        
            tx.commit();
        } catch(HibernateException e) {
            throw new HibernateException(e);    
        } finally {
            session.close();
            return almacen;
        }         
     
     }
}
